Sauberer Code beginnt mit

Module & Pakete

# import · package · pip · venv · requirements

# Beispiel: Standardbibliothek + Alias
import math as m
radius = 3
flaeche = m.pi * radius ** 2
print(f"A = {{"{flaeche:.2f}"}}")

Los geht's → Mini-Projekt ↓

▸ 01 — Grundlagen

Modul vs. Paket – was ist der Unterschied?

In Python bedeutet Modul meistens: eine Datei (z.B. tools.py). Ein Paket ist: ein Ordner mit mehreren Modulen (z.B. utils/). Beides hilft dir, große Projekte übersichtlich zu strukturieren.

📄

Modul

Eine .py-Datei mit Funktionen, Klassen oder Variablen.

📁

Paket

Ein Ordner mit mehreren Modulen (meist inkl. __init__.py).

🧱

Projekt

Sammlung aus Paketen + Dateien + (optional) venv + requirements.

💡

Du nutzt Module/Pakete jeden Tag, ohne es zu merken: import random, import time, import os … Das sind Module aus der Standardbibliothek.

▸ 02 — import

import: Module laden

Mit import lädst du ein Modul. Danach greifst du mit Punktnotation auf Inhalte zu: modul.funktion().

import_basics.py

            import random
            import time
            
            zahl = random.randint(1, 6)
            print(f"Würfel: {{"{zahl}"}}")
            time.sleep(1) # 1 Sekunde warten
          

⚠️

Achte darauf, dass deine Datei nicht so heißt wie ein Modul. Wenn du z.B. deine Datei random.py nennst, kann import random plötzlich dein eigenes File importieren.

▸ 03 — from ... import ...

Gezielt importieren

Mit from modul import name importierst du nur bestimmte Dinge – danach kannst du sie direkt verwenden.

🎯

Einzelne Funktion

Du holst nur, was du brauchst.

              from math import sqrt

              print(sqrt(9))

🧰

Mehrere Namen

Kommagetrennt importieren.

              from random import randint, choice

              print(randint(1,10))

💡

Kein Stern-Import: from modul import * wirkt zwar bequem, macht Code aber unübersichtlich (du weißt nicht mehr, woher ein Name kommt).

▸ 04 — Aliase

as: Kurzname vergeben

Aliase sind Standard in Python – z.B. import numpy as np. Das spart Tippaufwand und macht Code lesbarer.

alias.py

            import datetime as dt
            now = dt.datetime.now()
            print(now)
          

▸ 05 — Eigene Module

Eigene .py-Datei importieren

Du kannst deine eigenen Funktionen in eine Datei auslagern und dann importieren. Das ist der nächste Schritt zu sauberem Projekt-Code.

tools.py

            # tools.py
            def add(a, b):
            return a + b
            
            def sub(a, b):
            return a - b
          

main.py

            # main.py
            import tools
            print(tools.add(3, 4)) # 7
          

⚠️

Damit import tools funktioniert, müssen main.py und tools.py im selben Ordner liegen (oder tools muss im Python-Suchpfad liegen).

▸ 06 — Pakete

Ein Paket ist ein Ordner voller Module

Pakete erlauben dir eine klare Struktur: z.B. utils, services, models. Imports funktionieren dann über den Pfad: from utils.tools import add.

ordnerstruktur.txt

            # Projektstruktur (Beispiel)
            projekt/
            main.py
            utils/
            __init__.py
            tools.py
          

import_aus_paket.py

            from utils.tools import add
            print(add(10, 5))
          

▸ 07 — Projektstruktur

So bleibt dein Projekt übersichtlich

Eine typische Struktur (gerade in VS Code) sieht so aus: src/ für Code, tests/ für Tests, data/ für Daten, und optional venv/ + requirements.txt.

🗂️

Faustregel

Ein Ordner = ein Thema. Keine 20.000 Zeilen in einer Datei.

🧭

Imports planen

Achte darauf, dass dein „Startpunkt“ klar ist (z.B. main.py).

💡

Tipp: Wenn du später z.B. Web-Apps baust, nutzt man oft ein Paket app oder src und startet über eine Datei wie main.py oder run.py.

▸ 08 — __init__.py

Was macht init.py?

__init__.py markiert einen Ordner als Paket. Außerdem kannst du dort festlegen, was beim Import „sichtbar“ sein soll.

utils/__init__.py

            # utils/__init__.py
            # Du kannst hier Exporte bündeln:
            from .tools import add, sub
            
            # Dann geht später: from utils import add
          

✨

Das . in from .tools import ... bedeutet: „importiere aus dem gleichen Paket“ (relativer Import).

▸ 09 — sys.path

Wo sucht Python nach Modulen?

Python sucht Module in mehreren Orten: im aktuellen Ordner, in der Standardbibliothek und in installierten Paketen. Diese Liste findest du in sys.path.

sys_path.py

            import sys
            for p in sys.path:
            print(p)
          

🧭

Wenn Imports „plötzlich“ nicht gehen, liegt es oft an der Arbeitsmappe (Working Directory) oder an einer falschen Projektstruktur.

▸ 10 — pip

Pakete installieren (pip)

pip ist der Paketmanager für Python. Damit installierst du externe Libraries (z.B. requests, flask, pandas). Installierte Pakete landen in deiner Python-Umgebung.

pip_commands.txt

            # Installieren
            pip install requests
            
            # Updaten
            pip install --upgrade requests
            
            # Liste anzeigen
            pip list
          

⚠️

Wenn du mehrere Python-Versionen hast, nutze lieber: python -m pip install ... Dann ist klar, welche Python-Installation gemeint ist.

▸ 11 — venv

Virtuelle Umgebungen (venv)

Eine virtuelle Umgebung ist eine isolierte Python-Installation pro Projekt. Dadurch vermischst du keine Pakete zwischen Projekten.

venv_setup.txt

            # Erstellen
            python -m venv venv
            
            # Aktivieren (Windows)
            venv\Scripts\activate
            
            # Aktivieren (macOS/Linux)
            source venv/bin/activate
            
            # Deaktivieren
            deactivate
          

🧪

In VS Code kannst du dann die venv als Interpreter auswählen – und installierst Pakete nur noch in dieser Umgebung.

▸ 12 — requirements.txt

Abhängigkeiten speichern

Damit andere (oder du in 3 Monaten 😄) dein Projekt starten können, speichert man Abhängigkeiten in requirements.txt.

requirements.txt

            # Erstellen:
            pip freeze > requirements.txt
            
            # Installieren:
            pip install -r requirements.txt
          

🧾

Pro-Tipp: Nutze venv + requirements.txt zusammen. Dann ist dein Projekt „reproduzierbar“.

▸ 13 — Praxis

Mini-Projekt: Calculator als Paket

Wir bauen eine kleine Rechner-Struktur wie in „echten“ Projekten: Ein Paket calc mit Modulen. So übst du Imports, __init__.py und Struktur.

projektstruktur_calc.txt

            calc_project/
            main.py
            calc/
            __init__.py
            ops.py
            io.py
          

calc/ops.py

            def add(a, b): return a + b
            def sub(a, b): return a - b
            def mul(a, b): return a * b
            def div(a, b):
            if b == 0: raise ZeroDivisionError("Division durch 0")
            return a / b
          

calc/io.py

            def read_float(prompt):
            while True:
            try:
            return float(input(prompt).replace(",", "."))
            except ValueError:
            print("Bitte eine Zahl eingeben.")
          

calc/__init__.py

            # Bündel-Exports
            from .ops import add, sub, mul, div
            from .io import read_float
          